home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / sos3-2.lha / src / psm / psm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-05  |  63.5 KB  |  1,960 lines
  1. /* --------------------------------------------------------------------------
  2.  * Copyright 1992 by Forschungszentrum Informatik (FZI)
  3.  *
  4.  * You can use and distribute this software under the terms of the licence
  5.  * you should have received along with this program.
  6.  * If not or if you want additional information, write to
  7.  * Forschungszentrum Informatik, "STONE", Haid-und-Neu-Strasse 10-14,
  8.  * D-7500 Karlsruhe 1, Germany.
  9.  * --------------------------------------------------------------------------
  10.  */
  11. // **************************************************************************
  12. // Module psm                                  Emil Sekerinski, Walter Zimmer
  13. //
  14. // **************************************************************************
  15. //  persistent storage manager: implementation 
  16. // **************************************************************************
  17.  
  18. //#define LOCKD_CORRECT
  19. /*
  20.    if defined
  21.    then fcntl is used for container locking
  22.    else flock is used for container locking
  23.    fi
  24.  
  25.    As discussed in README.install, the default is "flock" (LOCKD_CORRECT not
  26.    defined), because of a bug in the SunOS lock demon.
  27.    The constant is set in the SOS Makefile when this file is compiled. See
  28.    the macro USE_FCNTL there.
  29. */
  30.  
  31. #include <sys/file.h>
  32. #include <osfcn.h>
  33. #include <libc.h>
  34. #include <errno.h>
  35. #include <sys/param.h>
  36. #include <string.h>
  37.  
  38. // *** necessary (and only allowed) when using  ATT 2.0 ***
  39. // #include <sys/time.h>
  40.  
  41. #ifndef SEEK_SET
  42. #define SEEK_SET    L_SET
  43. #define SEEK_CUR    L_INCR
  44. #define SEEK_END    L_XTND
  45. #endif
  46.  
  47.  
  48. #include "psm.h"
  49. #include "psm_err.h"   // err_raise, err_SYS
  50. #include "trc_psm.h"   // trace-module; numbers 11(H) -14(VL) + psm_CHECK
  51. #ifdef MONITOR
  52. #include "mon.h"       // mon_Window,mon_create,mon_black,mon_white,mon_close
  53. #endif
  54. #include "knl_use.h"   // 
  55.  
  56. // *******************   const definitions   *********************************
  57.  
  58. const UNUSED=0;        //  used for id's (value must be zero !)
  59. const UNDEF=-1;        //  used fur fileindex, bufferindex (also for fd in open())
  60.                        // for test, if object still exists or not (see list
  61.                //  free blocks)
  62.  
  63. const SIZEOF_INT = 4;        // if this is not valid => psm must be rewritten (!)
  64. const C=61;                  // container table size (max. number of open containers)
  65. const P=1024;                // page size in bytes
  66. const int DEFAULT_BUFFERSIZE = 128;    // def. size for paging buffer (can be
  67.                                        // changed by SOSBUFFERSIZE/MONITOR)
  68. const N=(P/SIZEOF_INT-4)/2; // =#pagetable entries per page and version
  69.                              // =#container pages between pagetable pages
  70. const MAX_FREEBLOCK_LENGTH = P - 1 * SIZEOF_INT; // maximum for the length
  71.                          // of a free block
  72. const SWITCH_OFFSET = 0;    // offset of switch in containerfile
  73. const err_msg ERR="container manager";
  74.  
  75. const sos_Container TEMP_CONTAINER=sos_Container::make (0);
  76. const sos_Container ROOT_CONTAINER=sos_Container::make (1);
  77. const sos_Container UNUSED_CONTAINER=sos_Container::make (0xffffffff); //2^32-1
  78. const sos_Offset ROOT_OFFSET=P; // bytes 0..P-1 used for table of free blocks.
  79.  
  80. // *******************   header variable definition  **************************
  81.  
  82. struct containerinfo 
  83. {
  84.     int id;        // 1<=id<2^24-1 or id==UNUSED
  85.     int status;        // container status: READABLE or WRITEABLE or CHECKEDOUT
  86.     int fd;        // file descriptor of container file
  87.     int sw;        // upper/lower pagetable switch for current version
  88.     int ubfreesize;    // upper bound (approximative) of the size of all free blocks,
  89.             // used for searching free blocks more efficiently
  90.     int contpages;    // number of container pages of current version
  91.     int conttablesize;    // size of the three subsequent arrays,must be multiple of N
  92.             // ( >= contpages)
  93.     int *bufferindex;    // maps [0..contpages) to [0..B)+UNDEF
  94.     int *fileindex;    // maps [0..contpages) to [0..filepages)+UNDEF (page table)
  95.     int *shadowed;    // maps [0..contpages) to bool
  96.             // (indicates, if shadow page exist)
  97.     int filepages;    // file pages occupied by the current container file
  98.             // (upper bound for reference from fileindex to containerpage)
  99.     int filetablesize;  // size of freefilepage array ( >= filepages )
  100.     int *freefilepage;  // maps [0..filepages) to bool, i.e., indicates the free
  101.                         // pages in the container file
  102.     int freefilepage_index;  // index to make search for next freefilepage more 
  103.                  // efficient; points to last found empty page (in 
  104.                  // the beginning => -1)
  105. #ifdef MONITOR
  106.     mon_Window win;
  107. #endif
  108. };
  109. static containerinfo containertable[C]; // `hash` table for container entries
  110.  
  111. static int B;     // number of pages in buffer, 1 <= B <= Bmax
  112. struct bufinfo   // info for each page in buf[0..B)
  113. {
  114.     int id, page;    // backward reference to container id and container page,
  115.                      // used for page replacement: id==UNUSED || (id==
  116.                  // containertable[?].id && 0<=page<containertable[?].contpages)
  117.     int referenced;  // used for page replacement (second chance algorithm)
  118.     int modified;    // indicates that page has to be written on commit
  119. };
  120.  
  121. static int buftable_index = 0;      // buffer table index : used for page replacement
  122.  
  123. typedef char PAGE[P];
  124.  
  125. static PAGE *buf;               // internal buffer for paging 
  126. static bufinfo *buftable;       // table of infos for each page of the buffer
  127.  
  128.  
  129. #ifdef MONITOR
  130. static int monactivated;
  131. #endif
  132.  
  133. // err_buffer is used for variable error messages
  134. // current use only in : lookupcontainer
  135. static char err_buffer[150];  
  136.  
  137. static struct initialize 
  138. {   // calls automatically psm_initialize when main program starts, because
  139.     // initialize() is constructor of struct initialize (standard trick)
  140.  
  141. initialize() {psm_initialize();} 
  142. } dummy;
  143.  
  144.  
  145. //-----------------------------------------------------------------------------
  146.  
  147. void psm_initialize() 
  148. {
  149.    B = DEFAULT_BUFFERSIZE;  // normal value of B if not monitoring 
  150.                 //                   &&  SOSBUFFERSIZE not set
  151.  
  152.    char* bufsize = getenv("SOSBUFFERSIZE");
  153.    if (bufsize != 0)   // SOSBUFFERSIZE is set
  154.    {
  155.       sscanf(bufsize,"%d",&B);
  156.       if (B <= 0)
  157.      B = DEFAULT_BUFFERSIZE;
  158.    }
  159.  
  160. #ifdef MONITOR
  161. monactivated = FALSE;
  162. char* e = getenv("SOSMONITOR");
  163. if (e != 0)
  164. {
  165.     sscanf(e,"%d",&B);
  166.     if (B > 0)
  167.     {
  168.     mon_initialize();
  169.     monactivated = TRUE;
  170.     }
  171.     else 
  172.        B = DEFAULT_BUFFERSIZE;
  173. }
  174. #endif
  175.  
  176. #if BOOT
  177.     srandom(1);
  178. #else
  179.     timeval tp;
  180.     gettimeofday(&tp,0);
  181.     srandom((int)tp.tv_sec);
  182. #endif
  183.  
  184.    buftable  = new bufinfo [B];                      // allocation of buffers
  185.    buf = new PAGE [B];
  186.  
  187.    int i,j;                             // initialization of buffers and tables
  188.    for (i = 0; i < C; i++) containertable[i].id = UNUSED;
  189.    for (i = 0; i < B; i++) buftable[i].id = UNUSED;
  190.    for (i = 0; i < B; i++) 
  191.       for (j = 0; j < P; j++) buf[i][j] = UNUSED;
  192.  
  193. }
  194.  
  195. //--------------------------------------------------------------------------
  196. // auxiliary functions   ( and inline functions )
  197. //--------------------------------------------------------------------------
  198.  
  199. inline int min(int a, int b) 
  200. {
  201.     return (a < b ? a : b); 
  202. }
  203.  
  204. inline int max(int a, int b) 
  205. {
  206.     return (a > b ? a : b); 
  207. }
  208.  
  209. inline int offrounded_pagenumber(int size)  // returns floor(size/P)
  210. {
  211.    return (int)(size / P);
  212. }
  213.  
  214. inline int uprounded_pagenumber(int size)   // returns ceil(size/P)
  215. {
  216.    return (int)((size + P - 1) / P);
  217. }
  218.  
  219. inline int N_upround(int nr)            // returns the next multiple of N
  220. {
  221.    return ((nr + N - 1) / N) * N;
  222. }
  223.  
  224. //--------------------------------------------------------------------------
  225.  
  226. inline int pagetable_offset(int page, int sw)
  227. {
  228.    // return offset of pagetable in containerfile, which contains entry for `page`.
  229.    // addition of offsets for
  230.    //  (1) page of pagetable  
  231.    //  (2) offset inside of this page (old or new pagetable)
  232.  
  233.    return (int)( (page/N) * (N+1) * P   +  (sw ? 4 : 4 + N) * SIZEOF_INT);
  234. }
  235. //--------------------------------------------------------------------------
  236.  
  237. inline int contpages_offset(int sw)
  238. {
  239.    return (int)( (sw ? 1 : 2) * SIZEOF_INT );
  240. }
  241. //--------------------------------------------------------------------------
  242. //--------------------   end of inline functions   -------------------------
  243. //--------------------------------------------------------------------------
  244.  
  245.  
  246.  
  247. static unsigned used_pages(containerinfo &ci) 
  248. {
  249.     // returns number of occupied pages (referenced from fileindex) 
  250.     // containerfile is normally larger than necessary because of unused
  251.     // pages and  shadowed pages (if container is open)
  252.  
  253.     unsigned used_pags = 0;
  254.     for (int p = 0; p < ci.contpages; p++)
  255.     if (ci.fileindex[p] != UNDEF) used_pags++;
  256.     return used_pags; 
  257. }
  258.  
  259. //--------------------------------------------------------------------------
  260.  
  261. static unsigned free_pages(containerinfo &ci) 
  262. {
  263.     // returns number of free places (UNDEF) in fileindex 
  264.  
  265.     return (ci.contpages - used_pages(ci)); 
  266. }
  267.  
  268. //------------------------------------------------------------------------------
  269.  
  270. static int lock(int fd, sos_Access_mode am, sos_Sync_mode sm) 
  271. {
  272.     T_PROC ("psm::lock");
  273.     TT (psm_H, T_ENTER; TI((int)fd);TI((int)am);TI((int)sm));
  274. /*
  275.     This version of lock uses the nfs locking mechanism via fcntl. Due to
  276.     bugs in the implementation, it may cause in a network of sun3 and sun4
  277.     stations the file server to crash !
  278. */
  279.  
  280. #ifdef LOCKD_CORRECT
  281.  
  282.     struct flock fl;
  283.     fl.l_type = (am == READING ? F_RDLCK : F_WRLCK);
  284.     fl.l_whence = 0; //starting offset = start of file
  285.     fl.l_start = 0;  //relative_offset=0
  286.     fl.l_len = 0;    //to end of file
  287.     int cmd = (sm == TESTING ? F_SETLK : F_SETLKW);
  288.     return fcntl(fd, cmd, (int)&fl) != -1;
  289.  
  290. /*
  291.     This version of lock sets the locks via flock. Locks obtained through
  292.     flock are only known to the system on which they are placed. Thus
  293.     inconsistencies may arise if the file is accessed via nfs from different
  294.     stations.
  295. */
  296.  
  297. #else
  298.  
  299.     int access = (am == READING ? LOCK_SH : LOCK_EX);
  300.     int sync = (sm == WAITING ? 0 : LOCK_NB);
  301.     TT (psm_H, T_LEAVE);
  302.     return flock(fd, access | sync) == 0;
  303.  
  304. #endif LOCKD_CORRECT
  305. }
  306.  
  307. //------------------------------------------------------------------------------
  308.  
  309. inline containerinfo* containertable_pos(int id)
  310. {
  311.     // returns containertable entry with key `id` (id == UNUSED == 0
  312.     // possible, see newcontainer), if container with `id` is opened, else UNDEF
  313.  
  314.     containerinfo *start, *probe;
  315.     probe =
  316.     start = &containertable[id % C];
  317.                   // in most cases a good starting point (see newcontainer)
  318.     do
  319.     {  if (probe->id == id) return probe;
  320.        probe = (probe == containertable) ? &containertable[C-1]
  321.                      : -- probe;
  322.     } while (probe != start);
  323.  
  324.     return (containerinfo *)UNDEF;
  325. }
  326.  
  327. //------------------------------------------------------------------------------
  328.  
  329.  
  330. inline int container_is_open(int id) 
  331. {
  332.     // returns TRUE, if its status equals  READABLE, WRITEABLE, CHECKEDOUT
  333.     // or DESTROYED, i.e. , if 'id' is in containertable
  334.  
  335.     return (containertable_pos(id) != (containerinfo *)UNDEF);
  336. }
  337.  
  338. //------------------------------------------------------------------------------
  339.  
  340. static containerinfo &newcontainer(int id) 
  341. {
  342.     containerinfo *start, *probe;
  343.     probe =
  344.     start = &containertable[id % C];
  345.         // in most cases a good starting point (see containertable_pos)
  346.     do
  347.     {  if (probe->id == UNUSED) return *probe;
  348.        probe = (probe == containertable) ? &containertable[C-1]
  349.                      : -- probe;
  350.     } while (probe != start);
  351.  
  352.     err_raise(err_SYS,err_PSM_CONTAINER_TABLE_FULL,ERR,FALSE);
  353.     return containertable[0];  // never reached! - only to avoid warnings
  354. }
  355.  
  356. //------------------------------------------------------------------------------
  357.  
  358. static containerinfo &lookupcontainer (int id,
  359.                        int open_on_read,
  360.                        int check_if_writing,
  361.                        int destroyed_permitted = FALSE) 
  362. {
  363.    // gives back the index in the containertable
  364.    // if container not in the containertable and open_on_read
  365.    //    -> implicit open if possible
  366.    // check_if_writing to control, whether the user has write permission
  367.    // destroyed_permitted  only is TRUE for operations, for which
  368.    // operations on destroyed containers are allowed 
  369.    // (destroy, close, commit, reset ; status, exists, object_exists)
  370.  
  371.    containerinfo *ct = containertable_pos(id);
  372.  
  373.    if (ct == (containerinfo *)UNDEF)
  374.       if (open_on_read)
  375.      if (sos_Container::make(id).open(READING,WAITING)==OPENED)
  376.          return lookupcontainer(id,FALSE,FALSE);
  377.      else
  378.      {   // 36 characters, 20 reserved for %d's, 70 for %s <= 150 characters
  379.          sprintf(err_buffer,"cannot open container %d\n\tUnix error %d : %.70s", id, errno,
  380.          (0 <= errno && errno < sys_nerr) ? sys_errlist[errno]
  381.                               : "***");
  382.          err_raise(err_SYS,err_buffer,ERR,FALSE);
  383.      }
  384.       else err_raise(err_SYS,err_PSM_UNOPENED_CONTAINER,ERR,FALSE);
  385.    else
  386.      if (ct->status == DESTROYED)
  387.         if (destroyed_permitted)
  388.        return *ct;  // avoid check_if_writing
  389.     else
  390.        err_raise(err_SYS,err_PSM_DESTROYED_CONTAINER,ERR,FALSE);
  391.  
  392.    if (check_if_writing  &&  ct->status != WRITEABLE)
  393.       err_raise(err_SYS,err_PSM_NONWRITEABLE_CONTAINER,ERR,FALSE);
  394.    return *ct; 
  395. }
  396.  
  397. //------------------------------------------------------------------------------
  398.  
  399. static void extendtable(int *&tab, int size, int newsize) 
  400. {  
  401.     int *newtab = new int[newsize];
  402.     for (int i = 0; i < size; i++) newtab[i] = tab[i];
  403.     for (i = size; i < newsize; i++) newtab[i] = 0;  // initialize with zero
  404.     delete tab;
  405.     tab = newtab;
  406. }
  407.  
  408. //------------------------------------------------------------------------------
  409.  
  410. static void calculatefreefilepages(containerinfo &ci) 
  411. {
  412.     // calculates ci.freefilepage, ci.filepages and clears ci.shadowed
  413.     // used only in readpagetable/writepagetable => ci.shadowed[]=FALSE
  414.  
  415.     for (int p = 0; p < ci.filetablesize; p++) ci.freefilepage[p] = TRUE;
  416.     ci.filepages = 0;
  417.     for (p = 0; p < ci.contpages; p++)
  418.     {   if (ci.fileindex[p] != UNDEF)
  419.     {   ci.freefilepage[ci.fileindex[p]] = FALSE;
  420.             ci.filepages = max (ci.filepages,ci.fileindex[p] + 1);
  421.     }
  422.         ci.shadowed[p] = FALSE; 
  423.     } 
  424. }
  425.  
  426.  
  427. //------------------------------------------------------------------------------
  428.  
  429. static int findfreefilepage(containerinfo &ci)
  430. { 
  431.     // returns number of first free file page, mark it as used
  432.     // and increment (if necessary) ci.filepages
  433.  
  434.     if (ci.filepages > 0)
  435.        ci.freefilepage_index = (ci.freefilepage_index + 1) % ci.filepages; 
  436.     else 
  437.        ci.freefilepage_index = 0;
  438.  
  439.     // "+1" for next possibly empty filepage; "% ci.filepages"
  440.     // because in writepagetable (in commit) the container can be truncated
  441.     // (decrease ci.filepages) and the ci.freefilepage_index can so point 
  442.     // to a location outside the container area
  443.  
  444.     int p = 0;
  445.     while (p < ci.filepages  &&  ! ci.freefilepage[ci.freefilepage_index])
  446.     {   p++;
  447.        ci.freefilepage_index = (ci.freefilepage_index + 1) % ci.filepages;
  448.     }
  449.  
  450.     if (p == ci.filepages)   // no free page found (else freefilepage_index
  451.                  // points to a free page)
  452.     {   if (ci.filetablesize == p)
  453.     {   extendtable(ci.freefilepage,p,2*p);
  454.             ci.filetablesize *= 2;
  455.     }
  456.         ci.filepages++; 
  457.     ci.freefilepage_index = p;
  458.     }
  459.  
  460.     ci.freefilepage[ci.freefilepage_index] = FALSE;
  461.     return ci.freefilepage_index; }
  462.  
  463. //------------------------------------------------------------------------------
  464.  
  465. static int fileposition(int filepage) 
  466. {   
  467.     // the term filepage/N+1 adjusts for the pages of the 
  468.     // "page table" scattered in the container file
  469.     // pages ( = filepage) +  pages of pagetable( = filepage/N)
  470.     //                    + rootoffset (1 = table of free blocks) 
  471.  
  472.     return (filepage + filepage/N + 1) * P; 
  473. }
  474.  
  475. //------------------------------------------------------------------------------
  476.  
  477. static void readpage(containerinfo &ci, int contpage, int bufpage)
  478. {
  479.     int filepage = ci.fileindex[contpage];
  480.     if (filepage == UNDEF) err_raise(err_SYS,err_PSM_WRONG_OFFSET,ERR,FALSE);
  481.     lseek(ci.fd, fileposition(filepage), SEEK_SET);
  482.     read(ci.fd, buf[bufpage], P); 
  483. }
  484.  
  485. //------------------------------------------------------------------------------
  486.  
  487. static void writepage(containerinfo &ci, int contpage, int bufpage)
  488. {
  489.     int &filepage = ci.fileindex[contpage];
  490.     if (filepage == UNDEF) err_raise(err_SYS,err_PSM_WRITEPAGE,ERR,FALSE);
  491.     if ( ! ci.shadowed[contpage])
  492.     {   filepage = findfreefilepage(ci);
  493.         ci.shadowed[contpage] = TRUE; 
  494.     }
  495.     lseek(ci.fd, fileposition(filepage), SEEK_SET);
  496.     write(ci.fd, buf[bufpage], P);
  497. }
  498.  
  499. //------------------------------------------------------------------------------
  500.  
  501. static int preemptpage(int id, int contpage) 
  502. {
  503.     // choose buffer page according to the second chance algorithm,
  504.     // write chosen page back to container file if necessary and
  505.     // mark chosen buffer page as used for 'contpage' of container 'id'.
  506.  
  507.     while (buftable[buftable_index].referenced)
  508.     { 
  509.     buftable[buftable_index].referenced = FALSE;
  510.         buftable_index =(buftable_index + 1) % B; 
  511.     }
  512.    if (buftable[buftable_index].id != UNUSED) 
  513.    {    containerinfo &ci = lookupcontainer(buftable[buftable_index].id,FALSE,FALSE);
  514.         if (buftable[buftable_index].modified)
  515.        writepage(ci,buftable[buftable_index].page,buftable_index);
  516.         ci.bufferindex[buftable[buftable_index].page] = UNDEF;
  517. #ifdef MONITOR
  518.         if (monactivated) mon_white(ci.win,buftable[buftable_index].page);
  519. #endif
  520.     }
  521.     buftable[buftable_index].id = id;
  522.     buftable[buftable_index].page = contpage;
  523.     buftable[buftable_index].modified = FALSE;
  524.     int result = buftable_index;
  525.     buftable_index = (buftable_index + 1) % B;
  526.     return result; }
  527.  
  528. //------------------------------------------------------------------------------
  529.  
  530. static int lookuppage(containerinfo &ci, int contpage) 
  531. {
  532.     // return index of buffer page of container ci's contpage
  533.     // if contpage not already in buffer, read it from the container file
  534.     // by swapping it with another container page if necessary.
  535.  
  536.     if (contpage >= ci.contpages) err_raise(err_SYS,err_PSM_WRONG_OFFSET,ERR,FALSE);
  537.     int &bufpage = ci.bufferindex[contpage];
  538.     if (bufpage == UNDEF)
  539.     {   bufpage = preemptpage(ci.id,contpage);
  540. #ifdef MONITOR
  541.         if (monactivated) mon_black(ci.win,contpage);
  542. #endif
  543.         readpage(ci,contpage,bufpage); 
  544.     }
  545.     buftable[bufpage].referenced = TRUE;
  546.     return bufpage; 
  547. }
  548.  
  549. //------------------------------------------------------------------------------
  550.  
  551. static int readint(containerinfo &ci, sos_Offset o)
  552. {
  553.     // pre: o%P+SIZEOF_INT<=P, i.e. data does not cross page boundary
  554.  
  555.     return * (int*) &buf[lookuppage(ci,o/P)][o%P]; 
  556. }
  557.  
  558. //------------------------------------------------------------------------------
  559.  
  560. static void writeint(containerinfo &ci, sos_Offset o, int a) 
  561. {
  562.     // pre: o%P+SIZEOF_INT<=P, i.e. data does not cross page boundary
  563.  
  564.     int bufpage = lookuppage(ci,o/P);
  565.     * (int*) &buf[bufpage][o%P] = a;
  566.     buftable[bufpage].modified = TRUE;
  567. }
  568.  
  569. //------------------------------------------------------------------------------
  570.  
  571. static void readfrompage(containerinfo &ci, int page, int disp, int len, void *data)
  572. {
  573.     // pre: disp+len<=P, i.e. data does not cross page boundary
  574.  
  575.     bcopy(&buf[lookuppage(ci,page)][disp], data, len); 
  576. }
  577.  
  578. //------------------------------------------------------------------------------
  579.  
  580. static void writetopage(containerinfo &ci, int page, int disp, int len, void *data) 
  581. {
  582.     // pre: disp+len<=P, i.e. data does not cross page boundary
  583.  
  584.     int bufpage = lookuppage(ci,page);
  585.     bcopy(data, &buf[bufpage][disp], len);
  586.     buftable[bufpage].modified = TRUE;
  587. }
  588.  
  589. //------------------------------------------------------------------------------
  590.  
  591. static void readpagetable(containerinfo &ci) 
  592. {
  593.     // read ci.sw, ci.contpages, ci.fileindex from container file,
  594.     // calculate ci.freefilepage, ci.filepages,
  595.     // clear ci.shadowed and initialize ci.ubfreesize
  596.  
  597.     if (lseek(ci.fd,0,SEEK_END) == 0)  // container file empty
  598.     {   ci.sw = 0;
  599.     ci.contpages = 0; 
  600.     }
  601.     else  // read ci.sw, ci.contpages, and ci.fileindex from file
  602.     {   lseek(ci.fd,SWITCH_OFFSET,SEEK_SET);                           // ci.sw
  603.     read(ci.fd,&ci.sw,SIZEOF_INT);
  604.     lseek(ci.fd,contpages_offset(ci.sw),SEEK_SET);                    //ci.contpages
  605.     read(ci.fd,&ci.contpages,SIZEOF_INT);
  606.     for (int i = 0; i < ci.contpages; i += N)            
  607.     {   lseek(ci.fd, pagetable_offset(i,ci.sw), SEEK_SET);
  608.         read(ci.fd, &ci.fileindex[i], N * SIZEOF_INT);
  609.     }
  610.     }
  611.     calculatefreefilepages(ci);
  612.     ci.ubfreesize = MAX_FREEBLOCK_LENGTH; }
  613.     
  614. //------------------------------------------------------------------------------
  615.  
  616. static void writepagetable(containerinfo &ci) 
  617. {
  618.     // toggle ci.sw and write ci.contpages, ci.fileindex to container file
  619.     // recalculate ci.freefilepage and clear ci.shadowed.
  620.  
  621.     ci.sw = !ci.sw;
  622.     lseek(ci.fd, contpages_offset(ci.sw), SEEK_SET);
  623.     write(ci.fd, &ci.contpages, SIZEOF_INT);
  624.     for (int i = 0; i < ci.contpages; i += N) 
  625.     {   lseek(ci.fd, pagetable_offset(i,ci.sw), SEEK_SET);
  626.         write(ci.fd, &ci.fileindex[i], N * SIZEOF_INT); 
  627.     }
  628.     fsync(ci.fd);
  629.     lseek(ci.fd, 0, SEEK_SET);
  630.     write(ci.fd, &ci.sw, SIZEOF_INT);
  631.     calculatefreefilepages(ci);
  632.     ftruncate(ci.fd,fileposition(ci.filepages)); 
  633. }
  634.  
  635. //------------------------------------------------------------------------------
  636.  
  637. static char* containerpath(int id)  // return pointer to path of container id
  638. {
  639.     static char n[MAXPATHLEN];
  640.     char* e = getenv("SOSCONTAINER");
  641.     if (e != 0)
  642.         if (strlen(e) < MAXPATHLEN-12)  // 12=length of containerfile-name
  643.     {
  644.             strcpy(n,e);
  645.             strcat(n,"/");
  646.         sprintf(n + strlen(n),"%d",id);
  647.         return n; 
  648.     }
  649.         else err_raise(err_SYS,err_PSM_PATH_TOO_LONG,ERR,FALSE);
  650.     else err_raise(err_SYS,err_NO_CONTAINER_PATH,ERR,FALSE); 
  651. }
  652.  
  653. //------------------------------------------------------------------------------
  654.  
  655. static void entercontainer(int id, int fd, sos_Access_mode a)
  656. {
  657.     // makes the necessary initializations for the containerinfo ci
  658.     // when opening a new container    
  659.  
  660.     fcntl(fd,F_SETFD,1);                                  // close on exec
  661.     containerinfo &ci = newcontainer(id);
  662.     ci.id = id;
  663.     ci.status = (sos_Container_status) a;
  664.     ci.fd = fd;
  665.     int realpages = uprounded_pagenumber(int(lseek(fd,0,SEEK_END)));
  666.        // total number of file pages
  667.  
  668.     int tablesize = (realpages == 0) ? N
  669.                      : N_upround(realpages);
  670.        // realpages rounded up to a positive multiple of N
  671.  
  672.     ci.conttablesize = tablesize;
  673.     ci.filetablesize = tablesize;
  674.     ci.fileindex = new int[tablesize];
  675.     ci.shadowed = new int[tablesize];
  676.     ci.freefilepage = new int[tablesize];
  677.     ci.freefilepage_index = -1;    // = no freefilepage found
  678.     readpagetable(ci);
  679.     ci.bufferindex = new int[tablesize];
  680.     for (int p = 0; p < ci.contpages; p++) ci.bufferindex[p] = UNDEF;
  681. #ifdef MONITOR
  682.     if (monactivated) 
  683.     {
  684.     ci.win = mon_create(ci.id, ci.contpages);
  685.     char *title;
  686.         if (ci.contpages <= 1) title = strdup ("<new>");
  687.         else
  688.     {
  689.          sos_Object o = sos_Container::make(ci.id).root_object();
  690.         if (o.isa (sos_Named_type))
  691.         title = sos_Named::make(o).get_name().make_Cstring();
  692.         else {
  693.             title = new char [12];
  694.             sprintf(title,"%d",ci.id); }
  695.     }
  696.         mon_open(ci.win,a,title);
  697.     delete title; 
  698.     }
  699. #endif
  700. }
  701.  
  702. //------------------------------------------------------------------------------
  703.  
  704. static void removecontainer(containerinfo &ci)
  705. {
  706.     for (int i = 0; i < B; i++)
  707.         if (buftable[i].id == ci.id)
  708.     {
  709.         buftable[i].id = UNUSED;
  710. #ifdef MONITOR
  711.         if (monactivated) mon_white(ci.win,buftable[i].page);
  712. #endif
  713.         }
  714.     ci.id = UNUSED;
  715.     delete ci.bufferindex;
  716.     delete ci.fileindex;
  717.     delete ci.shadowed;
  718.     delete ci.freefilepage;
  719.     close(ci.fd);   //also unlocks file
  720. #ifdef MONITOR
  721.     if (monactivated) mon_close(ci.win);
  722. #endif
  723.     }
  724.  
  725. //------------------------------------------------------------------------------
  726.  
  727. static void commitcontainer(containerinfo &ci) 
  728. {
  729.     for (int p = 0; p < ci.contpages; p++)
  730.         if (ci.bufferindex[p] != UNDEF && buftable[ci.bufferindex[p]].modified) {
  731.             writepage(ci,p,ci.bufferindex[p]);
  732.             buftable[ci.bufferindex[p]].modified = FALSE; }
  733.     writepagetable(ci); 
  734. }
  735.  
  736. //------------------------------------------------------------------------------
  737.  
  738. static void resetcontainer(containerinfo &ci)
  739. {
  740.     if (ci.status == DESTROYED) ci.status = WRITEABLE;
  741.     // a container could only be destroyed with status WRITEABLE 
  742.  
  743.     for (int p = 0; p < ci.contpages; p++)   // deallocate modified pages in buffer
  744.         if (ci.bufferindex[p] != UNDEF && buftable[ci.bufferindex[p]].modified) 
  745.     {
  746.             buftable[ci.bufferindex[p]].id=UNUSED;
  747.             ci.bufferindex[p] = UNDEF; 
  748.         }
  749.     readpagetable(ci);                      // readpagetable from containerfile
  750. }
  751.  
  752. //------------------------------------------------------------------------------
  753.  
  754. static void squeezecontainer(containerinfo &ci) 
  755. {
  756.     int u = used_pages(ci);
  757.     for (int p = 0; p < ci.contpages; p++)
  758.     if (ci.fileindex[p] >= u)                      // pre : UNDEF < 0
  759.         buftable[lookuppage(ci,p)].modified = TRUE; 
  760.  
  761.     ci.freefilepage_index = -1;    // reset freefilepage_index 
  762.  
  763.     // if it doesn't equal -1 then it happens this in the following commit:
  764.     // the modified pages could be written (see commit -> findfreefilepage ->...)
  765.     // to free pages at the end of the container file
  766.     // => the container will not be truncated (or only parts of) after the commit
  767. }
  768.  
  769. //------------------------------------------------------------------------------
  770.  
  771. static unsigned allocatepages(containerinfo &ci, int n) 
  772. {
  773.     // returns offset of n consecutive free pages and marks them as used
  774.  
  775.     int p = 0, f = 0, s = 0;
  776.     while (s < n  &&  p < ci.contpages)
  777.         if (ci.fileindex[p] == UNDEF) {s++; p++;}
  778.         else {s = 0; p++; f = p;} 
  779.     if (s < n)
  780.     {
  781.         ci.contpages +=  n - s;
  782.         if (ci.conttablesize < ci.contpages)
  783.     {   int newsize = N_upround (ci.contpages);
  784.             extendtable(ci.bufferindex, ci.conttablesize, newsize);
  785.             extendtable(ci.fileindex, ci.conttablesize, newsize);
  786.             extendtable(ci.shadowed, ci.conttablesize, newsize);
  787.             ci.conttablesize = newsize; 
  788.         } 
  789.     }
  790.     for (s = 0; s < n; s++) 
  791.     {   ci.fileindex[f+s] = findfreefilepage(ci);
  792.         ci.shadowed[f+s] = TRUE;
  793.         ci.bufferindex[f+s] = preemptpage(ci.id, f+s);
  794. #ifdef MONITOR
  795.         if (monactivated) mon_black(ci.win,f+s);
  796. #endif
  797.         buftable[ci.bufferindex[f+s]].modified = TRUE;
  798.         bzero(buf[ci.bufferindex[f+s]], P); 
  799.      }
  800.     return f * P; 
  801. }
  802.  
  803. //------------------------------------------------------------------------------
  804.  
  805. static void deallocatepages(containerinfo &ci, int p, int n) 
  806. {
  807.     // mark n consecutive pages starting with page p as unused
  808.  
  809.     while (n > 0) 
  810.     {
  811.     if (ci.shadowed[p]) 
  812.     {     ci.freefilepage[ci.fileindex[p]] = TRUE; 
  813.           // only to shadowed pages because of a possible reset to the container
  814.           ci.shadowed[p] = FALSE; 
  815.     }
  816.     ci.fileindex[p] = UNDEF;
  817.     if (ci.bufferindex[p] != UNDEF) 
  818.     {
  819.           buftable[ci.bufferindex[p]].id = UNUSED;
  820.           ci.bufferindex[p] = UNDEF; 
  821.     }
  822.     n--; p++; 
  823.     } 
  824. }  
  825.  
  826. //------------------------------------------------------------------------------
  827.  
  828. static unsigned size_of_free_blocks(containerinfo &ci) 
  829. {
  830.     int sum = 0;
  831.     for (int sz = 4; sz <= MAX_FREEBLOCK_LENGTH; sz += 4) 
  832.     {  int o = sz;
  833.        while (readint(ci,o) != 0) { // sum all free blocks of size sz
  834.        sum += sz; o = readint(ci,o); }
  835.     }
  836.     return sum;
  837. }
  838.  
  839. //------------------------------------------------------------------------------
  840.  
  841. static unsigned freesize(containerinfo &ci) 
  842. {
  843.     // free size of logical container, not of container file
  844.  
  845.     return (free_pages(ci) * P + size_of_free_blocks(ci));
  846. }
  847.  
  848. //------------------------------------------------------------------------------
  849.  
  850. #ifndef NO_TT
  851.  
  852. // check_freelists checks for a block (given by containerinfo, start and length
  853. // of the block), if it overlaps with a block in the freelist of the container
  854. // (the freelist contains previous deallocated blocks).
  855. // if (_psm_checked_cnt == 0) check all containers
  856. // else                       check only  _psm_checked_cnt
  857.  
  858. const sos_Container _psm_checked_cnt = sos_Container::make (0);
  859.  
  860. void check_freelists (containerinfo &ci, int start, int length)
  861. {  if ( ( _psm_checked_cnt  == 0  ||  _psm_checked_cnt == ci.id)
  862.     &&  ci.id != 0)
  863.    {
  864.        for (int size = 4; size <= MAX_FREEBLOCK_LENGTH; size += 4)  
  865.        {  // iterate over lists of different size
  866.  
  867.       int offset = readint(ci,size);
  868.       while (offset != 0)     
  869.       {
  870.          if ((start >= offset  &&  start < (offset + size)) 
  871.         || (start < offset  &&  (start + length) > offset))
  872.              err_raise(err_SYS,err_PSM_FREELIST_CHECK_FAILED,ERR,FALSE);
  873.          offset = readint(ci,offset);  // next list_element
  874.           }
  875.        }
  876.     }
  877. }
  878.  
  879. #endif NO_TT
  880.  
  881. // ******************************************************************************
  882. //           functions of class sos_Container
  883. // ******************************************************************************
  884. /*
  885. static void sos_Container::compress()
  886. {
  887.    // compress (or merges) blocks of the freelist
  888.  
  889.    containerinfo &ci = lookupcontainer(id,FALSE,FALSE);
  890.  
  891.    int *A = new int[ci.contpages];                        // initialization of A
  892.    for (int i = 0; i < ci.contpages; i++) A[i] = UNDEF;
  893.  
  894.  
  895.    for (int size = 4; size <= MAX_FREEBLOCK_LENGTH; size += 4)  
  896.    {  // Iterate over blocks of the freelist  &  destroy freelists (!)
  897.  
  898.       int current_offset1 = readint(ci,size);  
  899.     // element which will be inserted in list 2
  900.       writeint(ci,size,UNDEF);           // listheader is destroyed
  901.  
  902.       while (current_offset1 != 0)     
  903.       {  next_offset1 = readint(ci,current_offset1);
  904.  
  905.      current_offset2 = A[i];         // offset of current element in list 2
  906.      last_offset2 = 0;               // offset of last    element in list 2
  907.  
  908.      while (current_offset1 > current_offset2  &&  current_offset2 != 0 )  
  909.      { // find right place in list2 to insert
  910.         last_offset2 = current_offset2;
  911.         current_offset2 = readint(ci, current_offset2);
  912.      }
  913.  
  914.      if (current_offset2 == A[i]   // insert at list header (list can be empty)
  915.      {  A[i] = current_offset1;
  916.         writeint(ci, current_offset1, current_offset2);
  917.      }
  918.      else 
  919.      {  if (last_offset == 0) 
  920.            err_raise(err_SYS,err_PSM_COMPRESS,ERR,FALSE); 
  921.         writeint(ci, last_offset2, current_offset1);
  922.         writeint(ci, current_offset1, current_offset2);
  923.      }
  924.  
  925.      current_offset1 = next_offset1;                   // next list element
  926.       }
  927.    }
  928.  
  929.    // Sort & Merge new lists
  930.  
  931.    for ( i = 0; i < ci.contpages; i++)
  932.    {  if (A[i] == UNDEF)
  933.      if (fileindex[i] == UNDEF)
  934.         newfileindex[i] = UNDEF;         // page 'i' is not allocated (used)
  935.      else 
  936.         newfileindex[i] = fileindex[i];  // page contains no free blocks
  937.       else
  938.      if (fileindex[i] == UNDEF)
  939.         err_raise(err_SYS,err_PSM_COMPRESS,ERR,FALSE);
  940.         // page 'i' is not allocated  but contains free blocks
  941.      else 
  942.         merge_blocks(i);
  943.    }
  944.  
  945. // ___ merge blocks
  946.  
  947. void merge_blocks()
  948. {
  949.    offset
  950.  
  951.  
  952.    ???   Problem, da ich Groesse der Bloecke nicht abgspeichert habe
  953.  
  954.    =>  bauche doch explizite andere Datenstruktur (entweder Liste oder Baum)
  955.      in GNU-Bibliotheken ?
  956.  
  957.  
  958.  
  959.  
  960.    delete A;
  961.  
  962. */
  963. //------------------------------------------------------------------------------
  964.  
  965. sos_Container sos_Container::create() 
  966. {
  967.     T_PROC ("sos_Container::create");
  968.     TT (psm_H, T_ENTER);
  969.  
  970.     int id, fd;
  971.     do
  972.     {
  973.         id = (int)(random()%0xfffffd)+2; // 1<id<2^24-1
  974.         fd = ::open(containerpath(id),O_RDWR | O_CREAT | O_EXCL,0664); 
  975.         // owner:rw, group:r others:r
  976.     }
  977.     while (fd == UNDEF  &&  errno == EEXIST);
  978.  
  979.     if (fd == UNDEF) err_raise(err_SYS,err_PSM_CREATE_FAILED,ERR,FALSE);
  980.     lock(fd,WRITING,WAITING);
  981.     entercontainer(id,fd,WRITING);
  982.  
  983.     TT (psm_H, T_LEAVE; TI((int)id));
  984.     return sos_Container::make (id);
  985. }
  986. //------------------------------------------------------------------------------
  987.  
  988. sos_Container_status sos_Container::status() const 
  989. {
  990.     // return status of an opened container  or  UNAVAILABLE, if not opened
  991.  
  992.     T_PROC ("sos_Container::status");
  993.     TT (psm_H, T_ENTER; TI(id));
  994.  
  995.     if (id == 0) err_raise(err_SYS,err_PSM_STATUS_ON_TEMP, ERR,FALSE);
  996.     containerinfo *ct = containertable_pos(id);
  997.  
  998.     sos_Container_status result
  999.        = (ct == (containerinfo *)UNDEF) ? (sos_Container_status) UNAVAILABLE
  1000.                     : (sos_Container_status) ct->status;
  1001.  
  1002.     TT (psm_H, T_LEAVE; TI(result));
  1003.     return result;
  1004. }
  1005.  
  1006.    
  1007. //------------------------------------------------------------------------------
  1008.  
  1009. sos_Open_result sos_Container::open(sos_Access_mode a, sos_Sync_mode s) const 
  1010. {
  1011.     T_PROC ("sos_Container::open");
  1012.     TT (psm_H, T_ENTER; TI(id); TI((int)a); TI((int)s));
  1013.  
  1014.     if (id == 0) err_raise(err_SYS,err_PSM_OPEN_ON_TEMP, ERR,FALSE);
  1015.     if ( ! container_is_open(id))  
  1016.     {   int fd = ::open(containerpath(id),O_RDWR,0644); // O_RDWR for upgrading
  1017.         if (fd == UNDEF) 
  1018.     {  TT (psm_H, T_LEAVE; TI((int)UNACCESSIBLE));
  1019.        return UNACCESSIBLE;
  1020.         }
  1021.         if (!lock(fd,a,s)) 
  1022.     {  ::close(fd);
  1023.            TT (psm_H, T_LEAVE; TI((int)LOCKED));
  1024.        return LOCKED;
  1025.         }
  1026.         entercontainer(id,fd,a); 
  1027.     }
  1028.     else
  1029.     {  containerinfo &ci = lookupcontainer(id,FALSE,FALSE);
  1030.        if (ci.status == READABLE  &&  a == WRITING)
  1031.        {  if (!lock(ci.fd,WRITING,s))
  1032.       {
  1033.          // attention if using flock: if exclusive flock fails and
  1034.          // you had an shared flock before then no lock exits
  1035.          // afterwards. Because of that one tries to set again a (new)
  1036.          // shared lock. If this fails -> errormessage
  1037.          // very seldom because between exclusive lock and shared
  1038.          // lock (milliseconds) the following must happen:
  1039.          // the other users with a shared lock must unset their
  1040.          // locks and someone must set an exclusive lock
  1041.           
  1042.          if (!lock(ci.fd,READING,TESTING)) 
  1043.         err_raise(err_SYS,err_PSM_LOST_ALL_LOCKS, ERR,FALSE);
  1044.          TT (psm_H, T_LEAVE; TI((int)LOCKED));
  1045.          return LOCKED;
  1046.       }
  1047.       ci.status = WRITEABLE;
  1048.        }
  1049.    }
  1050.  
  1051.     TT (psm_H, T_LEAVE; TI((int)OPENED));
  1052.     return OPENED;
  1053. }
  1054.  
  1055. //------------------------------------------------------------------------------
  1056.  
  1057. sos_Open_result sos_Container::access(sos_Access_mode a, sos_Sync_mode s) const
  1058. {
  1059.     // only used for upgrading/downgrading
  1060.     // implicit commit if downgrading
  1061.  
  1062.     T_PROC ("sos_Container::access");
  1063.     TT (psm_H, T_ENTER; TI(id); TI((int)a); TI((int)s));
  1064.  
  1065.     if (id == 0) err_raise(err_SYS,err_PSM_ACCESS_ON_TEMP, ERR,FALSE);
  1066.     if ( ! container_is_open(id)) err_raise(err_SYS,err_PSM_NO_ACCESS,ERR,FALSE);
  1067.     containerinfo &ci = lookupcontainer(id,FALSE,FALSE);
  1068.     if (ci.status == WRITEABLE) commitcontainer(ci);
  1069.     if (!lock(ci.fd,a,s))
  1070.       //  attention if using flock (see 20 lines above) if upgrading fails
  1071.       //     you have no lock anymore therefore try again a shared lock
  1072.     {  if (!lock(ci.fd,READING,TESTING)) 
  1073.           err_raise(err_SYS,err_PSM_LOST_ALL_LOCKS, ERR,FALSE); 
  1074.        else if (ci.status == READABLE)  
  1075.        {  TT(psm_H, T_LEAVE; TI((int)LOCKED)); 
  1076.       return LOCKED;
  1077.        }
  1078.     }
  1079.     ci.status = (sos_Container_status) a;
  1080.  
  1081.     TT (psm_H, T_LEAVE; TI((int)OPENED));
  1082.     return OPENED; 
  1083. }
  1084.  
  1085. //------------------------------------------------------------------------------
  1086.  
  1087. void sos_Container::close() const 
  1088. {
  1089.  
  1090.     T_PROC ("sos_Container::close");
  1091.     TT (psm_H, T_ENTER; TI(id));
  1092.  
  1093.     if (id == 0) err_raise(err_SYS,err_PSM_CLOSE_ON_TEMP, ERR,FALSE);
  1094.     containerinfo &ci = lookupcontainer(id,FALSE,FALSE,TRUE);
  1095.     if (ci.status == WRITEABLE) commitcontainer(ci);
  1096.     if (ci.status == DESTROYED) unlink(containerpath(id));
  1097.     removecontainer(ci);
  1098.  
  1099.     TT (psm_H, T_LEAVE); 
  1100. }
  1101.  
  1102. //------------------------------------------------------------------------------
  1103.  
  1104. void sos_Container::destroy() const 
  1105. {
  1106.  
  1107.    T_PROC ("sos_Container::destroy");
  1108.    TT (psm_H, T_ENTER; TI(id));
  1109.  
  1110.    if (id == 0) err_raise(err_SYS,err_PSM_DESTROY_ON_TEMP, ERR,FALSE);
  1111.    containerinfo &ci = lookupcontainer(id,FALSE,TRUE,TRUE);
  1112.    if (ci.status == CHECKEDOUT)    // WRITEABLE and CHECKEDOUT differ only
  1113.                    // in this operation
  1114.       err_raise(err_SYS,err_PSM_DESTROY_DURING_CHECKOUT,ERR,FALSE);
  1115.  
  1116.    if (ci.status != DESTROYED)  
  1117.    {   clear();   //   clear is not necessary, but saves space
  1118.          //   (clear is only called for the first destroy)
  1119.       ci.status = DESTROYED;
  1120.    }
  1121.    TT (psm_H, T_LEAVE); 
  1122. }
  1123.  
  1124. //------------------------------------------------------------------------------
  1125.  
  1126. void sos_Container::commit() const 
  1127. {
  1128.     T_PROC ("sos_Container::commit");
  1129.     TT (psm_H, T_ENTER; TI(id));
  1130.  
  1131.     if (id == 0) err_raise(err_SYS,err_PSM_COMMIT_ON_TEMP, ERR,FALSE);
  1132.     containerinfo& ci = lookupcontainer(id,FALSE,TRUE,TRUE);
  1133.     if (ci.status == DESTROYED) 
  1134.     {
  1135.        unlink(containerpath(id));
  1136.        removecontainer(ci);
  1137.     }
  1138.     else
  1139.        commitcontainer(ci);
  1140.  
  1141.     TT (psm_H, T_LEAVE); 
  1142. }
  1143.  
  1144. //------------------------------------------------------------------------------
  1145.  
  1146. void sos_Container::reset() const 
  1147. {
  1148.     T_PROC ("sos_Container::reset");
  1149.     TT (psm_H, T_ENTER; TI(id));
  1150.  
  1151.     if (id == 0) err_raise(err_SYS,err_PSM_RESET_ON_TEMP, ERR,FALSE);
  1152.     resetcontainer(lookupcontainer(id,FALSE,TRUE,TRUE));
  1153.  
  1154.     TT (psm_H, T_LEAVE); 
  1155. }
  1156.  
  1157. //------------------------------------------------------------------------------
  1158.  
  1159. void sos_Container::squeeze() const 
  1160. {
  1161.     T_PROC ("sos_Container::squeeze");
  1162.     TT (psm_H, T_ENTER; TI(id));
  1163.  
  1164.     if (id == 0) err_raise(err_SYS,err_PSM_COMMIT_ON_TEMP, ERR,FALSE);
  1165.     containerinfo &ci = lookupcontainer(id,FALSE,TRUE);
  1166.     commitcontainer(ci);
  1167.     squeezecontainer(ci);
  1168.     commitcontainer(ci); 
  1169.  
  1170.     TT (psm_H, T_LEAVE); 
  1171. }
  1172.  
  1173. //------------------------------------------------------------------------------
  1174.  
  1175. unsigned sos_Container::allocate(unsigned size) const 
  1176. {
  1177.  
  1178.     T_PROC ("sos_Container::allocate");
  1179.     TT (psm_M, T_ENTER; TI(id); TI(size) );
  1180.  
  1181.     unsigned result;
  1182.  
  1183.     if (size == 0) err_raise(err_SYS,err_PSM_ALLOC_NULL_BYTES,ERR,FALSE);
  1184.     if (id == 0)
  1185.     {  result = (unsigned) new char [size];
  1186.        if (result == 0) err_raise(err_SYS,err_PSM_TEMP_FULL,ERR,FALSE);
  1187.     }
  1188.    else
  1189.    {  containerinfo &ci = lookupcontainer(id,FALSE,TRUE);
  1190.       if (ci.contpages == 0)  // allocate page with table of free blocks
  1191.       {  allocatepages(ci,1);
  1192.          ci.ubfreesize = 0; 
  1193.       }
  1194.       if (size <= MAX_FREEBLOCK_LENGTH)
  1195.       {  // lookup in table of free blocks, which stands in the first
  1196.      // page of the container
  1197.      // ( lists of free blocks are only used in :
  1198.      //   allocate/deallocate, size_of_free_blocks, check_free_lists,
  1199.      //   (object_exists)  )
  1200.  
  1201.          size=rounded(size);
  1202.      result = readint(ci,size);
  1203.          if (result != 0)  // free block of identical size exists
  1204.             writeint(ci,size,readint(ci,result)); 
  1205.          else  // try to find block of larger size, starting at size
  1206.      {  int sz = size + 4;    // sz > size
  1207.             while (sz <= ci.ubfreesize  &&  readint(ci,sz) == 0)
  1208.            sz += 4;
  1209.             if (sz <= ci.ubfreesize)               // readint(ci,sz) != 0
  1210.         {  result = readint(ci,sz);
  1211.  
  1212.            // new first list element
  1213.            writeint(ci,sz,readint(ci,result));  
  1214.  
  1215.            // insert rest of bigger block (of length sz - size) in table of
  1216.            // free blocks
  1217.            writeint(ci,result+size,readint(ci,sz - size));
  1218.            writeint(ci,sz - size,result + size); 
  1219.         }
  1220.         else                                  // sz > ci.ubfreesize  
  1221.         {  result = allocatepages(ci,1);
  1222.  
  1223.            // insert rest of page in table of free blocks
  1224.            writeint(ci,result + size,readint(ci,P - size));
  1225.            writeint(ci,P - size,result + size);
  1226.            ci.ubfreesize = max(ci.ubfreesize, P-size); 
  1227.         }
  1228.      } 
  1229.       }
  1230.       else result = allocatepages(ci, uprounded_pagenumber(size)); 
  1231.    }
  1232.  
  1233.    TT (psm_M, T_LEAVE; TI(result));
  1234.    return result;
  1235. }
  1236.  
  1237. //----------------------------------------------------------------------------
  1238.     
  1239. void sos_Container::deallocate(sos_Offset o, unsigned size) const 
  1240. {
  1241.     T_PROC ("sos_Container::deallocate");
  1242.     TT (psm_M, T_ENTER; ; TI(id); TI(o); TI(size));
  1243.     
  1244.     if (size == 0)  err_raise(err_SYS,err_PSM_DEALLOC_NULL_BYTES,ERR,FALSE);
  1245.     if (id == 0) delete (char*) o;
  1246.     else 
  1247.       if (o < 1024) err_raise(err_SYS,err_PSM_DEALLOCATE_WRONG_OFFSET, ERR,FALSE); 
  1248.     else 
  1249.     {  containerinfo &ci = lookupcontainer(id,FALSE,TRUE);
  1250.        TTN (psm_CHECK_WRITE, check_freelists (ci, o, size));
  1251.        if (size <= MAX_FREEBLOCK_LENGTH)     //enter in table of free blocks
  1252.        {   size = rounded(size);
  1253.        writeint(ci,o,readint(ci,size));  // link together with list 
  1254.        writeint(ci,size,o);
  1255.        ci.ubfreesize = max(ci.ubfreesize,size); 
  1256.  
  1257.        if (size >= 8)   writeint(ci,o+SIZEOF_INT,UNDEF); 
  1258.        //flag to indicate, that object is deleted:necessary for object_exists()
  1259.        }
  1260.        else deallocatepages(ci,o/P,uprounded_pagenumber(size)); 
  1261.     }
  1262.  
  1263.     TT (psm_M, T_LEAVE) 
  1264. }
  1265.  
  1266. //--------------------------------------------------------------------------
  1267.  
  1268. int sos_Container::modified() const 
  1269. { 
  1270.    // return whether sos_Container has been modified since last commit
  1271.    // not implemented by status-bit because then in many functions this bit 
  1272.    // must be set/unset
  1273.    // type of returnvalue not of type sos_Bool because  psm.h must
  1274.    // stand before  knl_use.h and  forward enum-declaration is not possible
  1275.    // container must be opened
  1276.  
  1277.    T_PROC ("sos_Container::modified");
  1278.    TT (psm_H, T_ENTER; TI(id));
  1279.  
  1280.    if (id == 0) err_raise(err_SYS,err_PSM_MODIFIED_ON_TEMP, ERR,FALSE); 
  1281.    containerinfo &ci = lookupcontainer(id,FALSE,FALSE);
  1282.  
  1283.    if (ci.status == WRITEABLE  ||  ci.status == CHECKEDOUT)
  1284.       for (int p = 0; p < ci.contpages; p++)   
  1285.          if (ci.bufferindex[p] != UNDEF  &&  buftable[ci.bufferindex[p]].modified)
  1286.      {  TT (psm_H, T_LEAVE; TI(TRUE));
  1287.         return TRUE;                      // at least one page is  modified
  1288.      }
  1289.  
  1290.    TT (psm_H, T_LEAVE; TI(FALSE));
  1291.    return FALSE;            //  read-only   or   not opened    or   not modified
  1292. }
  1293.  
  1294. //--------------------------------------------------------------------------
  1295.  
  1296. int sos_Container::exists() const 
  1297. {
  1298.    // returns whether container exists
  1299.    // or not (i.e., file is destroyed  or  container has been destroyed, but the
  1300.    // operation has been not yet  committed)
  1301.  
  1302.    T_PROC ("sos_Container::exists");
  1303.    TT (psm_H, T_ENTER; TI(id));
  1304.  
  1305.    int result = FALSE;          // modified 24/10/91 (bs)
  1306.  
  1307.    switch (status())
  1308.    {
  1309.       case READABLE:
  1310.       case WRITEABLE:
  1311.       case CHECKEDOUT:  result = TRUE;
  1312.                         break;
  1313.  
  1314.       case DESTROYED:   result = FALSE;
  1315.                         break;
  1316.  
  1317.       case UNAVAILABLE: int fd = ::open(containerpath(id),O_RDONLY);
  1318.             if (fd != UNDEF) 
  1319.             {  ::close(fd);
  1320.                result = TRUE;
  1321.             }
  1322.                         break;
  1323.        default:  err_raise(err_SYS,err_PSM_EXISTS,ERR,FALSE);
  1324.          break;
  1325.    };
  1326.    TT (psm_H, T_LEAVE; TI(result));
  1327.    return result; 
  1328. }
  1329.  
  1330. //--------------------------------------------------------------------------
  1331.  
  1332. int sos_Container::deleted() const
  1333. { 
  1334.    // returns whether file ,which belongs to container, is deleted or not
  1335.  
  1336.    T_PROC ("sos_Container::deleted"); TT (psm_H, T_ENTER; TI(id));
  1337.    TT (psm_H, T_LEAVE; TI(!exists())); 
  1338.    return (! exists());
  1339. }
  1340. //--------------------------------------------------------------------------
  1341.  
  1342. sos_Existing_status sos_Container::object_exists(sos_Offset o, unsigned size) const 
  1343. {
  1344.    // returns whether the object exists (perhaps) or not (sure)
  1345.    // pre: offset & size belongs to former objects in that container
  1346.    // else access outside allocated area is possible
  1347.    // (no TRACE inserted because of the many return statements)
  1348.  
  1349.    int flag;
  1350.  
  1351.    if (id == 0)  return PERHAPS_EXISTING;                 // temporary container
  1352.    if ( rounded(size) < 8) return PERHAPS_EXISTING;       // no sos_Object
  1353.    if (o < 1024) return NOT_EXISTING;                     // wrong offset
  1354.  
  1355.    if (! container_is_open(id))                  // container-file(!) not opened
  1356.    {  // now similar statements as in entercontainer      //   or not existing
  1357.  
  1358.       int sw,contpages;
  1359.       int fd = ::open(containerpath(id),O_RDONLY); 
  1360.  
  1361.       if (fd == UNDEF) return NOT_EXISTING;               // file does not exist
  1362.  
  1363.       lseek(fd, SWITCH_OFFSET,SEEK_SET);                     // switch
  1364.       ::read(fd,&sw,SIZEOF_INT);
  1365.  
  1366.       lseek(fd,contpages_offset(sw),SEEK_SET);               // number of contpages
  1367.       ::read(fd,&contpages,SIZEOF_INT);
  1368.  
  1369.       if (contpages == 0)  return NOT_EXISTING;           // container file empty
  1370.  
  1371.       int contpage = o / P;                               // logical container page
  1372.       if (contpage > contpages) return NOT_EXISTING; 
  1373.  
  1374.       // pagetable_offset in containerfile  +  page_offset inside pagetable
  1375.       lseek(fd, pagetable_offset(contpage,sw) + (contpage%N) * SIZEOF_INT, SEEK_SET);
  1376.       ::read(fd,&contpage,SIZEOF_INT);                   // page in file
  1377.  
  1378.       if (size <= MAX_FREEBLOCK_LENGTH) 
  1379.       {  if (contpage==UNDEF)  return NOT_EXISTING;   // WRONG_OFFSET
  1380.  
  1381.      lseek(fd,fileposition(contpage) + o%P + SIZEOF_INT,SEEK_SET); //offset in file
  1382.        // fileposition(contpage) + offset inside of page
  1383.        //  + SIZEOF_INT (for special bytes (=flagbyte) extra for this function)
  1384.      ::read(fd,&flag,SIZEOF_INT);
  1385.      return (flag == UNDEF) ? NOT_EXISTING : PERHAPS_EXISTING;
  1386.       }
  1387.       else  // look only at first of (possibly) several pages because of efficiency
  1388.       {  
  1389.      return (contpage == UNDEF)  ? NOT_EXISTING : PERHAPS_EXISTING;
  1390.       }
  1391.    }
  1392.    else                                                // container opened 
  1393.    {  containerinfo &ci = lookupcontainer(id,FALSE,FALSE,TRUE);
  1394.       if (sos_Container_status(ci.status) == DESTROYED) return NOT_EXISTING;
  1395.       if (size <= MAX_FREEBLOCK_LENGTH)  
  1396.       {  // offset 'cannot' be wrong (see:precondition)  because never
  1397.          // merge free blocks to greater free blocks (pages) 
  1398.  
  1399.       if (uprounded_pagenumber(o + size) > ci.contpages) return NOT_EXISTING;  
  1400.       flag = readint(ci, o + SIZEOF_INT );   
  1401.       return (flag == UNDEF) ? NOT_EXISTING : PERHAPS_EXISTING;  
  1402.       }
  1403.       else    // if one of the pages is UNDEF or no more existing (>contapges)
  1404.       {       // => object is  NOT_EXISTING
  1405.  
  1406.      if (o % P != 0) return NOT_EXISTING;   // offset must be a multiple of P
  1407.          int upper_bound = uprounded_pagenumber(o + size);
  1408.      for (int p = o/P; p < upper_bound; p++)
  1409.         if ((p > ci.contpages) || (ci.fileindex[p] == UNDEF)) return NOT_EXISTING;
  1410.  
  1411.          return PERHAPS_EXISTING;
  1412.       }
  1413.    }
  1414. }
  1415.  
  1416. //--------------------------------------------------------------------------
  1417.  
  1418. sos_Open_result sos_Container::checkout(sos_Access_mode, sos_Sync_mode) const
  1419. {
  1420.    err_raise_not_implemented ("sos_Container::checkout (will be realized by sos_Container::open(CHECKOUT, sync_mode)");
  1421.    return UNACCESSIBLE;
  1422. }
  1423.  
  1424. //--------------------------------------------------------------------------
  1425.  
  1426. unsigned sos_Container::rounded(unsigned size) const
  1427. {
  1428.     return (unsigned) (((size+3) /4) *4); 
  1429. }
  1430.  
  1431. //--------------------------------------------------------------------------
  1432.  
  1433. void sos_Container::clear() const 
  1434. {
  1435.     T_PROC ("sos_Container::clear");
  1436.     TT (psm_H, T_ENTER; TI(id));
  1437.  
  1438.     if (id == 0) err_raise(err_SYS,err_PSM_CLEAR_ON_TEMP, ERR,FALSE);
  1439.     containerinfo &ci = lookupcontainer(id,FALSE,TRUE);
  1440.     deallocatepages(ci,0,ci.contpages);
  1441.     ci.contpages = 0; 
  1442.     
  1443.     TT (psm_H, T_LEAVE); 
  1444. }
  1445.  
  1446. //--------------------------------------------------------------------------
  1447.  
  1448. unsigned sos_Container::occupied() const 
  1449. {
  1450.     // occupied bytes (data which is referenced from fileindex) in the container file
  1451.  
  1452.     T_PROC ("sos_Container::occupied");
  1453.     TT (psm_H, T_ENTER; TI(id));
  1454.  
  1455.     if (id == 0) err_raise(err_SYS,err_PSM_EMPTY_ON_TEMP, ERR,FALSE);
  1456.     containerinfo &ci = lookupcontainer(id,FALSE,FALSE);
  1457.  
  1458.     // substract from used_pages all free blocks and first page (table of 
  1459.     // free blocks)
  1460.  
  1461.     TT (psm_H, T_LEAVE); 
  1462.     return (ci.contpages == 0 ? 0 : used_pages(ci)*P - size_of_free_blocks(ci) - P);
  1463. }
  1464.  
  1465. //--------------------------------------------------------------------------
  1466.  
  1467. void sos_Container::read(sos_Offset o, unsigned size, void* data) const 
  1468. {
  1469.     T_PROC ("sos_Container::read");
  1470.     TT (psm_M, T_ENTER; TI(id); TI(o); TI(size); TP(data));
  1471.  
  1472.     if (id == 0) bcopy((char*)o,data,size);
  1473.     else if (size > 0)
  1474.     {   containerinfo &ci = lookupcontainer(id,TRUE,FALSE);
  1475.         TTN (psm_CHECK_READ, check_freelists (ci, o, size));
  1476.  
  1477.     char *d = (char*)data;
  1478.     int  len;
  1479.         while (1)
  1480.     {   int disp = o % P; // displacement in page
  1481.  
  1482.         if ((len = P-disp) >= size)
  1483.         {  readfrompage(ci,o/P,disp,size,d);
  1484.            break;
  1485.         }
  1486.             readfrompage(ci,o/P,disp,len,d);
  1487.             o += len;    
  1488.             d += len; 
  1489.         size -= len; }
  1490.         } 
  1491.  
  1492.     TT (psm_M, T_LEAVE); 
  1493. }
  1494.  
  1495. //--------------------------------------------------------------------------
  1496.  
  1497. void sos_Container::write(sos_Offset o, unsigned size, void* data) const 
  1498. {
  1499.    T_PROC ("sos_Container::write");
  1500.    TT (psm_M, T_ENTER; TI(id); TI(o); TI(size); TP(data));
  1501.  
  1502.    if (id == 0) bcopy(data,(char*)o,size);
  1503.    else 
  1504.    {  char *d = (char*)data;
  1505.       containerinfo &ci = lookupcontainer(id,FALSE,TRUE);
  1506.       TTN (psm_CHECK_WRITE, check_freelists (ci, o, size));
  1507.       while (size > 0)
  1508.       {
  1509.       int disp = o%P; // displacement in page
  1510.       int len = min(size, P-disp);
  1511.       writetopage(ci,o/P,disp,len,d);
  1512.       o += len;    
  1513.       d += len;
  1514.       size -= len; 
  1515.       } 
  1516.    } 
  1517.  
  1518.    TT (psm_M, T_LEAVE); 
  1519. }
  1520.  
  1521. //--------------------------------------------------------------------------
  1522.  
  1523. void sos_Container::copy(sos_Offset o1, unsigned size, sos_Container c2,
  1524.     sos_Offset o2) const 
  1525. {
  1526.     T_PROC ("sos_Container::copy");
  1527.     TT (psm_M, T_ENTER; TI(id); TI(o1); TI(size); TI((int)c2); TI(o2));
  1528.  
  1529.     containerinfo *ci1 = containertable,*ci2 = containertable;
  1530.     int d1,d2;
  1531.     char *a1,*a2;
  1532.     if (id != 0) ci1 = &lookupcontainer(id,TRUE,FALSE);
  1533.     if (c2.id != 0) ci2 = &lookupcontainer(c2.id,FALSE,TRUE);
  1534.     if (o1 > o2) //copy from low to high
  1535.         while (size > 0) 
  1536.     {
  1537.             if (id == 0) {d1 = 0; a1 = (char*) o1;}
  1538.             else {d1 = o1 % P; a1 = buf[lookuppage(*ci1,o1/P)] + d1; }
  1539.             if (c2.id == 0) {d2 = 0; a2 = (char*) o2;}
  1540.             else 
  1541.         {   d2 = o2 % P;
  1542.                 int destbufpage = lookuppage(*ci2,o2/P);
  1543.                 a2 = buf[destbufpage] + d2;
  1544.                 buftable[destbufpage].modified = TRUE;
  1545.         }
  1546.             int len = min(size,min(P-d1,P-d2));
  1547.             bcopy(a1,a2,len);
  1548.             o1 += len; o2 += len; size -= len; 
  1549.         }
  1550.     else  //copy from high to low
  1551.     {   o1 += size - 1; o2 += size - 1;
  1552.         while (size > 0) 
  1553.     {   if (id == 0) {d1 = P; a1 = (char*) o1 + 1;}
  1554.             else {d1 = o1%P + 1; a1 = buf[lookuppage(*ci1,o1/P)] + d1; }
  1555.             if (c2.id == 0) {d2 = P; a2 = (char*) o2 + 1;}
  1556.             else 
  1557.         {
  1558.                 d2 = o2%P + 1;
  1559.                 int destbufpage = lookuppage(*ci2,o2/P);
  1560.                 a2 = buf[destbufpage] + d2;
  1561.                 buftable[destbufpage].modified = TRUE; 
  1562.         }
  1563.             int len = min(size,min(d1,d2));
  1564.             bcopy(a1-len,a2-len,len);
  1565.             o1 -= len; o2 -= len; size -= len; 
  1566.         } 
  1567.    }
  1568.  
  1569.     TT (psm_M, T_LEAVE); 
  1570. }
  1571.  
  1572. //--------------------------------------------------------------------------
  1573.  
  1574. int sos_Container::equal(sos_Offset o1, unsigned size, sos_Container c2,
  1575.     sos_Offset o2) const 
  1576. {
  1577.     T_PROC ("sos_Container::equal");
  1578.     TT (psm_M, T_ENTER; TI(id); TI(o1); TI(size); TI((int)c2); TI(o2));
  1579.  
  1580.     containerinfo *ci1 = containertable,*ci2 = containertable;
  1581.     int d1,d2;
  1582.     char *a1,*a2;
  1583.     if (id == 0) d1 = 0; else ci1 = &lookupcontainer(id,TRUE,FALSE);
  1584.     if (c2.id == 0) d2 = 0; else ci2 = &lookupcontainer(c2.id,TRUE,FALSE);
  1585.     while (size > 0) 
  1586.     {   if (id == 0) a1 = (char*) o1;
  1587.         else {d1 = o1%P; a1 = buf[lookuppage(*ci1,o1/P)] + d1; }
  1588.         if (c2.id == 0) a2 = (char*) o2;
  1589.         else {d2 = o2%P; a2 = buf[lookuppage(*ci2,o2/P)] + d2; }
  1590.         int len = min(size,min(P-d1,P-d2));
  1591.         if (bcmp(a1,a2,len) != 0) 
  1592.     {  TT(psm_M, T_LEAVE; TI(FALSE));
  1593.        return FALSE;
  1594.     }
  1595.         o1 += len; o2 += len; size -= len; 
  1596.     }
  1597.  
  1598.     TT(psm_M, T_LEAVE; TI(TRUE));
  1599.     return TRUE; 
  1600. }
  1601.  
  1602. //--------------------------------------------------------------------------
  1603.  
  1604. int sos_Container::hash_value (sos_Offset o, unsigned size) const 
  1605. {
  1606.     T_PROC ("sos_Container::hash_value");
  1607.     TT (psm_H, T_ENTER; TI(id); TI(o); TI(size));
  1608.  
  1609.     unsigned u = o + size;
  1610.     unsigned l = SIZEOF_INT;
  1611.     int result = 0;
  1612.     int data;
  1613.     for ( ; o < u; o += l) 
  1614.     {   if (l > u - o) { l = u - o; data = 0; } // if size is not a multiple 
  1615.                                                 // of SIZEOF_INT
  1616.         read (o, l, &data);
  1617.         result ^= data; 
  1618.     }
  1619.     TT(psm_H, T_LEAVE; TI(result));
  1620.     return result; 
  1621. }
  1622.  
  1623. //--------------------------------------------------------------------------
  1624.  
  1625. sos_Object sos_Container::root_object() const 
  1626. {
  1627.   return sos_Object::make (sos_Typed_id::make (sos_Id::make (*this, ROOT_OFFSET))); 
  1628. }
  1629.  
  1630. // ********************************************************************
  1631. //              functions of class sos_Container_set
  1632. // ********************************************************************
  1633.  
  1634. /*
  1635. // copy constructors do not worrk correctly for the gnu-compilers  !!!
  1636. sos_Container_set::sos_Container_set(const sos_Container_set& cs)
  1637. {
  1638.     size = cs.size;
  1639.     n = cs.n;
  1640.     s = new int[size];
  1641.     int* s2 = cs.s;
  1642.     for (int i = 0; i < n; ++i)
  1643.        *s++ = *s2++;
  1644. }
  1645.  
  1646.  
  1647. sos_Container_set& sos_Container_set::operator=(const sos_Container_set& cs)
  1648. {
  1649.     size = cs.size;
  1650.     n = cs.n;
  1651.     s = new int[size];
  1652.     int* s2 = cs.s;
  1653.     for (int i = 0; i < n; ++i)
  1654.        *s++ = *s2++;
  1655.     
  1656.     // during test , after program termination clobbereed space detected
  1657.     // also false results (false container in set)
  1658.     // during compilation: warning because of bitwise ...
  1659.     // psmtest.c:7: warning: bitwise copy: `sos_Container_set' defines operator=()
  1660. }
  1661.  
  1662. */
  1663.  
  1664. sos_Container_set::sos_Container_set() 
  1665. {
  1666.     T_PROC ("sos_Container_set::sos_Container_set");
  1667.     TT (psm_H, T_ENTER);
  1668.  
  1669.     size = 16;
  1670.     s = new int[size];
  1671.     n = 0; 
  1672.  
  1673.     TT (psm_H, T_LEAVE);
  1674. }
  1675.  
  1676. sos_Container_set::~sos_Container_set()
  1677. // { delete [size] s; } // must be inserted again (after presentation)
  1678. {
  1679. }
  1680.  
  1681. sos_Container_set& sos_Container_set::operator+=(sos_Container c) 
  1682. {
  1683.     T_PROC ("sos_Container_set::operator+=");
  1684.     TT (psm_H, T_ENTER);
  1685.  
  1686.     if ( c == TEMP_CONTAINER) err_raise(err_SYS,err_PSM_ADD_WITH_TEMP, ERR,FALSE);
  1687.     if (n == size) {extendtable(s,size,2*size); size *= 2; }
  1688.     TT (psm_H, T_LEAVE);
  1689.     for (int i = 0; i < n; ++i)   // multiple appearance of the same container
  1690.        if (s[i] == c)           // in one set (not bag!) not allowed
  1691.       return *this;
  1692.     s[n] = (int)c; n++; return *this; 
  1693. }
  1694.  
  1695. sos_Open_result sos_Container_set::op(int i,const sos_Container_set& rd,const  
  1696.            sos_Container_set& wr, sos_Sync_mode s) 
  1697. {
  1698.     if (i < rd.card()) return sos_Container::make(rd.s[i]).open(READING,s);
  1699.     else return sos_Container::make(wr.s[i-rd.n]).open(WRITING,s); 
  1700. }
  1701.  
  1702. void sos_Container_set::cl(int i,const sos_Container_set& rd,const sos_Container_set& wr) 
  1703. {
  1704.     if (i < rd.card()) sos_Container::make(rd.s[i]).close();
  1705.     else sos_Container::make(wr.s[i-rd.n]).close(); 
  1706. }
  1707.  
  1708. sos_Open_result sos_Container_set::open(const sos_Container_set& rd, 
  1709.       const sos_Container_set& wr, sos_Sync_mode s)
  1710. {
  1711.     T_PROC ("sos_Container_set::open");
  1712.     TT (psm_H, T_ENTER);
  1713.  
  1714.     int i = 0;
  1715.     while (i <  rd.card() + wr.card())
  1716.  
  1717.         switch (sos_Container_set::op(i,rd,wr,TESTING)) {
  1718.             case OPENED: i++; break;
  1719.             case UNACCESSIBLE:
  1720.                 for (int j = 0; j < i; j++) sos_Container_set::cl(j,rd,wr);
  1721.                 TT (psm_H, T_LEAVE; TI((int)UNACCESSIBLE));
  1722.                 return UNACCESSIBLE;
  1723.             case LOCKED:
  1724.                 for (int k = 0; k < i; k++) sos_Container_set::cl(k,rd,wr);
  1725.                 if (s == TESTING) 
  1726.         {   TT (psm_H, T_LEAVE; TI((int)LOCKED));
  1727.            return LOCKED;
  1728.         }
  1729.                 switch (sos_Container_set::op(i,rd,wr,WAITING)) {
  1730.                     case UNACCESSIBLE:  TT (psm_H, T_LEAVE; TI((int)UNACCESSIBLE));
  1731.                                        return UNACCESSIBLE;
  1732.                     case OPENED: sos_Container_set::cl(i,rd,wr); i = 0; } }
  1733.  
  1734.     TT (psm_H, T_LEAVE; TI((int)OPENED));
  1735.     return OPENED; 
  1736. }
  1737.  
  1738. //--------------------------------------------------------------------------
  1739.  
  1740. sos_Container_set& sos_Container_set::open_containers(sos_Container_status stat)
  1741. {
  1742.    // returns set of containers openend for WRITING/READING dependent on status
  1743.  
  1744.    T_PROC ("sos_Container_set::open_containers");
  1745.    TT (psm_H, T_ENTER);
  1746.  
  1747.    sos_Container_set* new_set = new sos_Container_set;
  1748.    for (int i = 0; i < C; i++) 
  1749.    {
  1750.     if ((containertable[i].id != UNUSED) && (containertable[i].status == stat))
  1751.             (*new_set) += sos_Container::make(containertable[i].id);
  1752.    }
  1753.    TT (psm_H, T_LEAVE);
  1754.    return (*new_set);
  1755. }
  1756.  
  1757. //--------------------------------------------------------------------------
  1758.  
  1759. sos_Open_result sos_Container_set::open(sos_Access_mode a, sos_Sync_mode s) const 
  1760. {
  1761.     sos_Container_set empty;
  1762.     if (a == READING) return sos_Container_set::open(*this,empty,s);
  1763.     else return sos_Container_set::open(empty,*this,s); 
  1764. }
  1765.  
  1766. //--------------------------------------------------------------------------
  1767.  
  1768. void sos_Container_set::close() const
  1769. {
  1770.     T_PROC ("sos_Container_set::close"); TT (psm_H, T_ENTER);
  1771.     for (int i = 0; i < card(); i++) sos_Container::make(s[i]).close(); 
  1772.     TT(psm_H, T_LEAVE);
  1773. }
  1774.  
  1775. //--------------------------------------------------------------------------
  1776.  
  1777. void sos_Container_set::commit() const 
  1778. {
  1779.     T_PROC ("sos_Container_set::commit"); TT (psm_H, T_ENTER);
  1780.     for (int i = 0; i < card(); i++) sos_Container::make(s[i]).commit(); 
  1781.     TT(psm_H, T_LEAVE);
  1782. }
  1783.  
  1784. //--------------------------------------------------------------------------
  1785.  
  1786. void sos_Container_set::reset() const 
  1787. {
  1788.     T_PROC ("sos_Container_set::reset"); TT (psm_H, T_ENTER);
  1789.     for (int i = 0; i < card(); i++) sos_Container::make(s[i]).reset(); 
  1790.     TT(psm_H, T_LEAVE);
  1791. }
  1792.  
  1793. // ************  sos_Container_set and sos_Container_cursor  *******************
  1794.  
  1795. sos_Container_cursor sos_Container_set::open_cursor() const 
  1796. {
  1797.    // creates a new cursor-object and positions it to the first element
  1798.    // if one exists
  1799.  
  1800.    T_PROC ("sos_Container_set::open_cursor"); TT (psm_L, T_ENTER);
  1801.    sos_Container_cursor new_c;
  1802.    new_c.idx = (card() > 0) ? 0 : -1 ;
  1803.    TT (psm_L, T_LEAVE; TI(new_c.idx));
  1804.    return new_c;
  1805. }
  1806.  
  1807. //--------------------------------------------------------------------------
  1808.  
  1809. void sos_Container_set::close_cursor (sos_Container_cursor &c) const 
  1810. { 
  1811.    T_PROC ("sos_Container_set::close_cursor"); TT (psm_L, T_ENTER);
  1812.    c.idx = -1;
  1813.    TT (psm_L, T_LEAVE);
  1814.    return;
  1815. }
  1816.  
  1817. //--------------------------------------------------------------------------
  1818.  
  1819. int sos_Container_set::to_succ (sos_Container_cursor& c) const 
  1820. {  
  1821.    // moves cursor one position further and return FALSE, if 'end of 
  1822.    // set' is reached, else TRUE
  1823.    T_PROC ("sos_Container_set::to_succ"); TT (psm_L, T_ENTER);
  1824.  
  1825.    if ( ++c.idx >= card() ) 
  1826.    {  c.idx = -1;
  1827.       TT (psm_L, T_LEAVE; TI(FALSE));
  1828.       return FALSE;
  1829.    } 
  1830.    else 
  1831.    {  TT (psm_L, T_LEAVE; TI(TRUE));
  1832.       return TRUE;
  1833.    }
  1834. } 
  1835.  
  1836. //--------------------------------------------------------------------------
  1837.  
  1838. int sos_Container_set::is_valid (sos_Container_cursor c) const 
  1839. { 
  1840.    T_PROC ("sos_Container_set::is_valid"); TT (psm_L, T_ENTER);
  1841.    TT (psm_L, T_LEAVE);
  1842.    return (c.idx >= 0  &&  c.idx < card());  
  1843. }
  1844.  
  1845. //--------------------------------------------------------------------------
  1846.  
  1847. sos_Container sos_Container_set::get (sos_Container_cursor c) const 
  1848. {
  1849.    T_PROC ("sos_Container_set::get"); TT (psm_L, T_ENTER);
  1850.    if ( ! this->is_valid(c))  err_raise(err_SYS,err_PSM_INVALID_CURSOR, ERR,FALSE); 
  1851.    TT (psm_L, T_LEAVE);
  1852.    return sos_Container::make(s[c.idx]);
  1853. }
  1854.  
  1855. //----------------------------------------------------------------------------
  1856. /*  TRACE generates for the functions of class sos_Container and sos_Container_set
  1857.     (and for function lock()) the following output:
  1858.  
  1859.        T_ENTER: name of function, container id  and all arguments of the function
  1860.        T_LEAVE: name of function and return argument
  1861.     
  1862.     exceptions for T_LEAVE 
  1863.        - no output of return argument :  status, occupied, lock, get, is_valid
  1864.     exceptions for T_ENTER
  1865.        - no output of id : create
  1866.  
  1867.     exception for TRACE at all: object_exists
  1868. */
  1869. //----------------------------------------------------------------------------
  1870. /*
  1871.  
  1872. //--------- to do for release SOS3-2 ----------------------------------
  1873.  
  1874.  - SOSBUFFERSIZE  - wo dokumentieren, wo ist SOS_MONITOR dokumentiert ???
  1875.  
  1876. --------- POSTPONED -------------
  1877.  
  1878. - destruktor fuer contaiener_set =>   .... Implementierung von container_set wie
  1879.     bei smg_string
  1880.  
  1881. - in object_exists Funktion readint_from_file herausfaktorisieren 
  1882.  
  1883.   EFFIZIENZTEST FUER INLINE ... (einmal fast nichts, einmal fast alle
  1884.   hilfsfkt. inline)
  1885.   - moeglichst viele Hilfsfunktonen  inline deklarieren => nur fuer die
  1886.   Hilfsfunktionen wird einmal Code angelegt bzw. so hauefig, we sie in den
  1887.   Interfacefunktionen vorkommen. Wie oft die Schnittstellenfunktionen aufgerufen
  1888.   werden, ist voellig egal, dort steht ja nur ein Funktionsaufruf.
  1889.  
  1890. - effizienzv improvement for read() ... with no use of bcopy
  1891.     (in read() ... replace bcopy, if size <=16, ...)
  1892.  
  1893. - compress
  1894.  
  1895. sos_Container als sos_Objects :
  1896.   ? Klasse als Schnittstelle darueberlegen
  1897.   ? sind containersets richtig implementiert :
  1898.      falls der Anwender unterprogramm mit paramater (nicht &) uerbergibt wird
  1899.      beim ruecksprung cnt_set zerstoert   und    wenn dem Anwender set
  1900.      uebergeben wird und dieser sein Programm beendet (macht nichts. da set nur
  1901.      im hauptspeicher ?!
  1902.  
  1903.      wie ist dies in SOS realisiert: referenzcounter, der bei 'copy' mitzaehlt
  1904.      wieviele referenzen auf dieses aggragate existieren und erst bei 0 dieses
  1905.      loescht
  1906.  
  1907. --------  DONE  ---------
  1908.  
  1909. - globale unix-variable fuer sosbuffersize
  1910.    - Benutzer kann sich selbst groesse waeheln
  1911.    - Zeitmessungen moeglich
  1912.  
  1913. - interne Funktionen verbessern bzw. erzeugen
  1914.    z.B. container_exists...
  1915.  
  1916. - sos_Access_mode/sos_CONtainer_status klar trennen .status/ c.status() / ...
  1917.  
  1918. - MAX_FREEBLOPCVKLENGTH = P-8 ersetzen durch P-4,   size oder rounded(size) <=
  1919. MAX... ist egal ...
  1920.  
  1921. - sos-gsh als test vom psm durchfuehren
  1922.  
  1923.   - checkout-Funktionsheader nicht direkjt loeschen, sondern durch Fehlermeldung
  1924.   " not implemented ..." ersetzzen"  und in keinem Fall in der Manpage
  1925.   erwaaehnen
  1926.  
  1927. - manpages aktualisieren und an vielen Stellen ausfuhrlivcher beschreiben
  1928.   - neue TRC-Switches psm_check_erad/write in Manpage beschreiben
  1929.  
  1930. - Destroy: siehe File "Destroy"
  1931.  
  1932. - Effizienz fuer sehr grosse Container ?
  1933.   Da das Laden der seitentabelle viel Zeit kostet (fuer groose Container) und
  1934.   auch das Zurueckschreiben bei commit, koenen auch kleine Aenderungen am
  1935.   Containerinhalt viel Zeit kosten (falls Container gross).
  1936.   Kann man dies verbessern?
  1937.  
  1938.   Beim Zurueckschreiben: nicht nur ein Switch fuer alle Teile der Seitentabelle
  1939.   verwalten, sondern fuer jeden Teil ein extra-Switch und ein Gesamt-Switch.
  1940.   Dadurch mueste man nur noch ein Byte (oder 4) statt 1024 Byte schreiben, falls
  1941.   sich der zugehoerige Teil der seitentabelle nicht geaendert hat. Mehraufwand
  1942.   waehren ein paar Abfragen ( ? und pruefen, welche Teile der Seitentabelle von
  1943.   den Aederungen betroffen sind ?). Lohnt sich sicher nur fuer sehr grosse
  1944.   Container, die daher nicht zu oft geoeefnet und geschlossen werden sollten.
  1945.  
  1946.   Beim Oeffnen des Containers: Die Seitentabelle musste "lazy" geladen weren,
  1947.   dass heisst die betreffenden Teile wereen nur dann in den Hauptspeicher
  1948.   geladen, wenn erforderlich. => viel komplizierter unf lohnt sich wirklich nur
  1949.   fuer sehr grosse Files (koennte man durch die Laenge der Seitentabelle anfangs
  1950.   abfragen und vielleicht als parameter beim oeffnen mitgeben: normal_open
  1951.   or 'open_with_lazy_changes"
  1952.  
  1953.  
  1954.  
  1955. */
  1956. //-----------------------------------------------------------------------------
  1957. // end of psm.c
  1958. //-----------------------------------------------------------------------------
  1959.  
  1960.